Resolves: #i121532# enhanced visualisation of text edit&selection
D&D overhauled
(cherry picked from commit c6e63b6bbb6b4a63fe1302de57fc32cd28432378)
Conflicts:
drawinglayer/inc/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
drawinglayer/inc/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
drawinglayer/inc/drawinglayer/processor2d/linegeometryextractor2d.hxx
drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx
svx/Package_inc.mk
svx/inc/svx/sdr/overlay/overlayanimatedbitmapex.hxx
svx/inc/svx/sdr/overlay/overlayobject.hxx
svx/inc/svx/sdr/overlay/overlaypolypolygon.hxx
svx/inc/svx/sdr/overlay/overlayrectangle.hxx
svx/inc/svx/sdr/overlay/overlaytools.hxx
svx/inc/svx/sdr/primitive2d/svx_primitivetypes2d.hxx
svx/inc/svx/svdview.hxx
svx/source/engine3d/view3d.cxx
svx/source/sdr/overlay/overlayanimatedbitmapex.cxx
svx/source/sdr/overlay/overlayhatchrect.cxx
svx/source/sdr/overlay/overlaypolypolygon.cxx
svx/source/sdr/overlay/overlaytools.cxx
svx/source/svdraw/svdcrtv.cxx
svx/source/svdraw/svdedxv.cxx
svx/source/svdraw/svdhdl.cxx
svx/source/svdraw/svdobj.cxx
svx/source/svdraw/svdview.cxx
sw/source/ui/dochdl/swdtflvr.cxx
Unname unused arguments to prevent WaE issues.
(cherry picked from commit 0735a61e631b8d4bb3d4e889bee436fb9e7c5734)
Change-Id: I3b1cf4754063985dc1b4adac44b33e52e200607f
e4288936cadd1f6e06bdf79611536d7114236b56
diff --git a/chart2/source/controller/main/DragMethod_RotateDiagram.cxx b/chart2/source/controller/main/DragMethod_RotateDiagram.cxx
index 00cada7..a983d85 100644
--- a/chart2/source/controller/main/DragMethod_RotateDiagram.cxx
+++ b/chart2/source/controller/main/DragMethod_RotateDiagram.cxx
@@ -215,7 +215,8 @@
// transform to 2D view coordinates
aPolyPolygon.transform(rVCScene.getObjectTransformation());
sdr::overlay::OverlayPolyPolygonStriped* pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(aPolyPolygon);
sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
aPolyPolygon);
rOverlayManager.add(*pNew);
addToOverlayObjectList(*pNew);
}
diff --git a/drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx b/drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx
index 7cd2a1a1..39cbdd8 100644
--- a/drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx
+++ b/drawinglayer/source/primitive2d/polypolygonprimitive2d.cxx
@@ -28,6 +28,8 @@
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <vcl/graph.hxx>
//////////////////////////////////////////////////////////////////////////////
@@ -111,7 +113,12 @@
for(sal_uInt32 a(0L); a < nCount; a++)
{
aRetval[a] = Primitive2DReference(new PolygonMarkerPrimitive2D(aPolyPolygon.getB2DPolygon(a), getRGBColorA(), getRGBColorB(), getDiscreteDashLength()));
aRetval[a] = Primitive2DReference(
new PolygonMarkerPrimitive2D(
aPolyPolygon.getB2DPolygon(a),
getRGBColorA(),
getRGBColorB(),
getDiscreteDashLength()));
}
return aRetval;
@@ -473,4 +480,107 @@
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
namespace drawinglayer
{
namespace primitive2d
{
Primitive2DSequence PolyPolygonSelectionPrimitive2D::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
{
Primitive2DSequence aRetval;
if(getTransparence() < 1.0 && getB2DPolyPolygon().count())
{
if(getFill() && getB2DPolyPolygon().isClosed())
{
// create fill primitive
const Primitive2DReference aFill(
new PolyPolygonColorPrimitive2D(
getB2DPolyPolygon(),
getColor()));
aRetval = Primitive2DSequence(&aFill, 1);
}
if(getDiscreteGrow() > 0.0)
{
const attribute::LineAttribute aLineAttribute(
getColor(),
getDiscreteGrow() * getDiscreteUnit() * 2.0);
const Primitive2DReference aFatLine(
new PolyPolygonStrokePrimitive2D(
getB2DPolyPolygon(),
aLineAttribute));
appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, aFatLine);
}
// embed filled to transparency (if used)
if(aRetval.getLength() && getTransparence() > 0.0)
{
const Primitive2DReference aTrans(
new UnifiedTransparencePrimitive2D(
aRetval,
getTransparence()));
aRetval = Primitive2DSequence(&aTrans, 1);
}
}
return aRetval;
}
PolyPolygonSelectionPrimitive2D::PolyPolygonSelectionPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const basegfx::BColor& rColor,
double fTransparence,
double fDiscreteGrow,
bool bFill)
: DiscreteMetricDependentPrimitive2D(),
maPolyPolygon(rPolyPolygon),
maColor(rColor),
mfTransparence(fTransparence),
mfDiscreteGrow(fabs(fDiscreteGrow)),
mbFill(bFill)
{
}
bool PolyPolygonSelectionPrimitive2D::operator==(const BasePrimitive2D& rPrimitive) const
{
if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
{
const PolyPolygonSelectionPrimitive2D& rCompare = (PolyPolygonSelectionPrimitive2D&)rPrimitive;
return (getB2DPolyPolygon() == rCompare.getB2DPolyPolygon()
&& getColor() == rCompare.getColor()
&& getTransparence() == rCompare.getTransparence()
&& getDiscreteGrow() == rCompare.getDiscreteGrow()
&& getFill() == rCompare.getFill());
}
return false;
}
basegfx::B2DRange PolyPolygonSelectionPrimitive2D::getB2DRange(const geometry::ViewInformation2D& rViewInformation) const
{
basegfx::B2DRange aRetval(basegfx::tools::getRange(getB2DPolyPolygon()));
if(getDiscreteGrow() > 0.0)
{
// get the current DiscreteUnit (not sure if getDiscreteUnit() is updated here, better go safe way)
const double fDiscreteUnit((rViewInformation.getInverseObjectToViewTransformation() * basegfx::B2DVector(1.0, 0.0)).getLength());
aRetval.grow(fDiscreteUnit * getDiscreteGrow());
}
return aRetval;
}
// provide unique ID
ImplPrimitive2DIDBlock(PolyPolygonSelectionPrimitive2D, PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D)
} // end of namespace primitive2d
} // end of namespace drawinglayer
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/include/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx b/include/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
index c6467f4..2899b37 100644
--- a/include/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
+++ b/include/drawinglayer/primitive2d/drawinglayer_primitivetypes2d.hxx
@@ -101,7 +101,8 @@
#define PRIMITIVE2D_ID_CROPPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 66)
#define PRIMITIVE2D_ID_PATTERNFILLPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 67)
#define PRIMITIVE2D_ID_OBJECTINFOPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 68)
#define PRIMITIVE2D_ID_CLIPPEDBORDERLINEPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 69)
#define PRIMITIVE2D_ID_POLYPOLYGONSELECTIONPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 69)
#define PRIMITIVE2D_ID_CLIPPEDBORDERLINEPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_DRAWINGLAYER| 70)
//////////////////////////////////////////////////////////////////////////////
diff --git a/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx b/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
index 0679ce4..4afb5ed 100644
--- a/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
+++ b/include/drawinglayer/primitive2d/polypolygonprimitive2d.hxx
@@ -30,6 +30,7 @@
#include <drawinglayer/attribute/linestartendattribute.hxx>
#include <drawinglayer/attribute/fillgradientattribute.hxx>
#include <drawinglayer/attribute/fillhatchattribute.hxx>
#include <drawinglayer/primitive2d/primitivetools2d.hxx>
#include <basegfx/color/bcolor.hxx>
//////////////////////////////////////////////////////////////////////////////
@@ -376,6 +377,70 @@
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
// PolyPolygonSelectionPrimitive2D class
namespace drawinglayer
{
namespace primitive2d
{
/** PolyPolygonSelectionPrimitive2D class
This primitive defines a PolyPolygon which gets filled with a defined color
and a defined transparence, but also gets extended ('grown') by the given
discrete size (thus being a view-dependent primitive)
*/
class DRAWINGLAYER_DLLPUBLIC PolyPolygonSelectionPrimitive2D : public DiscreteMetricDependentPrimitive2D
{
private:
/// the PolyPolygon geometry
basegfx::B2DPolyPolygon maPolyPolygon;
/// the color
basegfx::BColor maColor;
/// the transparence [0.0 .. 1.0]
double mfTransparence;
/// the discrete grow size ('pixels'), only posivive values allowed
double mfDiscreteGrow;
/// bitfield
/// draw polygons filled when fill is set
bool mbFill : 1;
protected:
/// local decomposition.
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
/// constructor
PolyPolygonSelectionPrimitive2D(
const basegfx::B2DPolyPolygon& rPolyPolygon,
const basegfx::BColor& rColor,
double fTransparence,
double fDiscreteGrow,
bool bFill);
/// data read access
const basegfx::B2DPolyPolygon& getB2DPolyPolygon() const { return maPolyPolygon; }
const basegfx::BColor& getColor() const { return maColor; }
double getTransparence() const { return mfTransparence; }
double getDiscreteGrow() const { return mfDiscreteGrow; }
bool getFill() const { return mbFill; }
/// compare operator
virtual bool operator==(const BasePrimitive2D& rPrimitive) const;
/// get range
virtual basegfx::B2DRange getB2DRange(const geometry::ViewInformation2D& rViewInformation) const;
/// provide unique ID
DeclPrimitive2DIDBlock()
};
} // end of namespace primitive2d
} // end of namespace drawinglayer
//////////////////////////////////////////////////////////////////////////////
#endif //INCLUDED_DRAWINGLAYER_PRIMITIVE2D_POLYPOLYGONPRIMITIVE2D_HXX
diff --git a/include/drawinglayer/processor2d/linegeometryextractor2d.hxx b/include/drawinglayer/processor2d/linegeometryextractor2d.hxx
index 4905f40..906dd9e 100644
--- a/include/drawinglayer/processor2d/linegeometryextractor2d.hxx
+++ b/include/drawinglayer/processor2d/linegeometryextractor2d.hxx
@@ -35,7 +35,7 @@
/** LineGeometryExtractor2D class
This processor can extract the line geometry from feeded primpitives. The
hairlines and the fille geometry from fat lines are separated.
hairlines and the fill geometry from fat lines are separated.
*/
class DRAWINGLAYER_DLLPUBLIC LineGeometryExtractor2D : public BaseProcessor2D
{
diff --git a/include/svx/sdr/overlay/overlayanimatedbitmapex.hxx b/include/svx/sdr/overlay/overlayanimatedbitmapex.hxx
index 756d2da..ee9a4a6 100644
--- a/include/svx/sdr/overlay/overlayanimatedbitmapex.hxx
+++ b/include/svx/sdr/overlay/overlayanimatedbitmapex.hxx
@@ -45,16 +45,13 @@
// #i53216# added CursorBlinkTime (in ms)
sal_uInt32 mnBlinkTime;
// bitfield
// Flag to remember which state to draw. Inited with sal_False (0)
unsigned mbOverlayState : 1;
/// bitfield
// Flag to remember which state to draw. Inited with false (0)
bool mbOverlayState : 1;
// geometry creation for OverlayObject
virtual drawinglayer::primitive2d::Primitive2DSequence createOverlayObjectPrimitive2DSequence();
// #i53216# check blink time value range (currently 25 < mnBlinkTime < 10000)
void impCheckBlinkTimeValueRange();
public:
OverlayAnimatedBitmapEx(
const basegfx::B2DPoint& rBasePos,
diff --git a/include/svx/sdr/overlay/overlayobject.hxx b/include/svx/sdr/overlay/overlayobject.hxx
index 263e9a9..3b56c97 100644
--- a/include/svx/sdr/overlay/overlayobject.hxx
+++ b/include/svx/sdr/overlay/overlayobject.hxx
@@ -82,6 +82,9 @@
// a missing implementation
virtual drawinglayer::primitive2d::Primitive2DSequence createOverlayObjectPrimitive2DSequence();
// #i53216# check blink time value range (currently 25 < mnBlinkTime < 10000)
sal_uInt32 impCheckBlinkTimeValueRange(sal_uInt32 nBlinkTime) const;
// region in logical coordinates
basegfx::B2DRange maBaseRange;
diff --git a/include/svx/sdr/overlay/overlaypolypolygon.hxx b/include/svx/sdr/overlay/overlaypolypolygon.hxx
index d7dd827..a716aac 100644
--- a/include/svx/sdr/overlay/overlaypolypolygon.hxx
+++ b/include/svx/sdr/overlay/overlaypolypolygon.hxx
@@ -22,6 +22,7 @@
#include <svx/sdr/overlay/overlayobject.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
//////////////////////////////////////////////////////////////////////////////
@@ -29,21 +30,23 @@
{
namespace overlay
{
class SVX_DLLPUBLIC OverlayPolyPolygonStriped : public OverlayObject
class SVX_DLLPUBLIC OverlayPolyPolygonStripedAndFilled : public OverlayObject
{
protected:
// geometry
basegfx::B2DPolyPolygon maPolyPolygon;
basegfx::B2DPolyPolygon maLinePolyPolygon;
// geometry creation for OverlayObject
virtual drawinglayer::primitive2d::Primitive2DSequence createOverlayObjectPrimitive2DSequence();
public:
explicit OverlayPolyPolygonStriped(const basegfx::B2DPolyPolygon& rPolyPolygon);
virtual ~OverlayPolyPolygonStriped();
explicit OverlayPolyPolygonStripedAndFilled(
const basegfx::B2DPolyPolygon& rLinePolyPolygon);
virtual ~OverlayPolyPolygonStripedAndFilled();
// change geometry
basegfx::B2DPolyPolygon getPolyPolygon() const { return maPolyPolygon; }
basegfx::B2DPolyPolygon getLinePolyPolygon() const { return maLinePolyPolygon; }
void setLinePolyPolygon(const basegfx::B2DPolyPolygon& rNew);
// react on stripe definition change
virtual void stripeDefinitionHasChanged();
diff --git a/include/svx/sdr/overlay/overlayrectangle.hxx b/include/svx/sdr/overlay/overlayrectangle.hxx
new file mode 100644
index 0000000..3d2f6f7
--- /dev/null
+++ b/include/svx/sdr/overlay/overlayrectangle.hxx
@@ -0,0 +1,87 @@
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef _SDR_OVERLAY_OVERLAYRECTANGLE_HXX
#define _SDR_OVERLAY_OVERLAYRECTANGLE_HXX
#include <svx/sdr/overlay/overlayobject.hxx>
#include <tools/gen.hxx>
//////////////////////////////////////////////////////////////////////////////
class PolyPolygon;
namespace sdr
{
namespace overlay
{
class OverlayRectangle : public OverlayObjectWithBasePosition
{
// geometric definitions
basegfx::B2DPoint maSecondPosition;
const double mfTransparence;
const double mfDiscreteGrow;
const double mfDiscreteShrink;
const double mfRotation;
// #i53216# added CursorBlinkTime (in ms)
sal_uInt32 mnBlinkTime;
/// bitfield
// Flag to remember which state to draw. Inited with false (0)
bool mbOverlayState : 1;
// geometry creation for OverlayObject
virtual drawinglayer::primitive2d::Primitive2DSequence createOverlayObjectPrimitive2DSequence();
public:
OverlayRectangle(
const basegfx::B2DPoint& rBasePosition,
const basegfx::B2DPoint& rSecondPosition,
const Color& rHatchColor,
double fTransparence,
double fDiscreteGrow,
double fDiscreteShrink,
double fRotation,
sal_uInt32 nBlinkTime,
bool bAnimate);
const basegfx::B2DPoint& getSecondPosition() const { return maSecondPosition; }
void setSecondPosition(const basegfx::B2DPoint&);
// data read access
double getTransparence() const { return mfTransparence; }
double getDiscreteGrow() const { return mfDiscreteGrow; }
double getDiscreteShrink() const { return mfDiscreteShrink; }
double getRotation() const { return mfRotation; }
// added CursorBlinkTime (in ms)
sal_uInt32 getBlinkTime() const { return mnBlinkTime; }
void setBlinkTime(sal_uInt32 nNew);
// execute event from base class ::sdr::animation::Event. Default
// implementation does nothing and does not create a new event.
virtual void Trigger(sal_uInt32 nTime);
};
} // end of namespace overlay
} // end of namespace sdr
//////////////////////////////////////////////////////////////////////////////
#endif //_SDR_OVERLAY_OVERLAYRECTANGLE_HXX
// eof
diff --git a/include/svx/sdr/overlay/overlaytools.hxx b/include/svx/sdr/overlay/overlaytools.hxx
index 408c81b..57bbcf7 100644
--- a/include/svx/sdr/overlay/overlaytools.hxx
+++ b/include/svx/sdr/overlay/overlaytools.hxx
@@ -118,16 +118,15 @@
{
namespace primitive2d
{
class OverlayHatchRectanglePrimitive : public DiscreteMetricDependentPrimitive2D
class OverlayRectanglePrimitive : public DiscreteMetricDependentPrimitive2D
{
private:
// the logic rectangle definition
basegfx::B2DRange maObjectRange;
// the hatch definition
double mfDiscreteHatchDistance;
double mfHatchRotation;
basegfx::BColor maHatchColor;
// the graphic definition
basegfx::BColor maColor;
double mfTransparence;
// the dscrete grow and shrink of the box
double mfDiscreteGrow;
@@ -140,20 +139,18 @@
virtual Primitive2DSequence create2DDecomposition(const geometry::ViewInformation2D& rViewInformation) const;
public:
OverlayHatchRectanglePrimitive(
OverlayRectanglePrimitive(
const basegfx::B2DRange& rObjectRange,
double fDiscreteHatchDistance,
double fHatchRotation,
const basegfx::BColor& rHatchColor,
const basegfx::BColor& rColor,
double fTransparence,
double fDiscreteGrow,
double fDiscreteShrink,
double fRotation);
// data access
const basegfx::B2DRange& getObjectRange() const { return maObjectRange; }
double getDiscreteHatchDistance() const { return mfDiscreteHatchDistance; }
double getHatchRotation() const { return mfHatchRotation; }
const basegfx::BColor& getHatchColor() const { return maHatchColor; }
const basegfx::BColor& getColor() const { return maColor; }
double getTransparence() const { return mfTransparence; }
double getDiscreteGrow() const { return mfDiscreteGrow; }
double getDiscreteShrink() const { return mfDiscreteShrink; }
double getRotation() const { return mfRotation; }
diff --git a/include/svx/sdr/primitive2d/svx_primitivetypes2d.hxx b/include/svx/sdr/primitive2d/svx_primitivetypes2d.hxx
index 6178695..42d5109 100644
--- a/include/svx/sdr/primitive2d/svx_primitivetypes2d.hxx
+++ b/include/svx/sdr/primitive2d/svx_primitivetypes2d.hxx
@@ -42,7 +42,7 @@
#define PRIMITIVE2D_ID_SDRBORDERLINEPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_SVX| 15)
#define PRIMITIVE2D_ID_OVERLAYBITMAPEXPRIMITIVE (PRIMITIVE2D_ID_RANGE_SVX| 16)
#define PRIMITIVE2D_ID_OVERLAYCROSSHAIRPRIMITIVE (PRIMITIVE2D_ID_RANGE_SVX| 17)
#define PRIMITIVE2D_ID_OVERLAYHATCHRECTANGLEPRIMITIVE (PRIMITIVE2D_ID_RANGE_SVX| 18)
#define PRIMITIVE2D_ID_OVERLAYRECTANGLEPRIMITIVE (PRIMITIVE2D_ID_RANGE_SVX| 18)
#define PRIMITIVE2D_ID_OVERLAYHELPLINESTRIPEDPRIMITIVE (PRIMITIVE2D_ID_RANGE_SVX| 19)
#define PRIMITIVE2D_ID_OVERLAYROLLINGRECTANGLEPRIMITIVE (PRIMITIVE2D_ID_RANGE_SVX| 20)
#define PRIMITIVE2D_ID_SDRCONTROLPRIMITIVE2D (PRIMITIVE2D_ID_RANGE_SVX| 21)
diff --git a/include/svx/svdview.hxx b/include/svx/svdview.hxx
index ef28a17..7628926 100644
--- a/include/svx/svdview.hxx
+++ b/include/svx/svdview.hxx
@@ -28,6 +28,8 @@
#include "svx/svxdllapi.h"
#include <svx/svdcrtv.hxx>
#include <unotools/options.hxx>
#include <basegfx/polygon/b2dpolypolygon.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
////////////////////////////////////////////////////////////////////////////////////////////////////
//
@@ -151,7 +153,9 @@
// The OverlayObjects
::sdr::overlay::OverlayObjectList maObjects;
void ImplCreateOverlays(const SdrView& rView, const basegfx::B2DPolyPolygon& rPolyPolygon);
void ImplCreateOverlays(
const SdrView& rView,
const basegfx::B2DPolyPolygon& rLinePolyPolygon);
public:
SdrDropMarkerOverlay(const SdrView& rView, const SdrObject& rObject);
diff --git a/sd/source/ui/view/sdview2.cxx b/sd/source/ui/view/sdview2.cxx
index e030435..fa14fe1 100644
--- a/sd/source/ui/view/sdview2.cxx
+++ b/sd/source/ui/view/sdview2.cxx
@@ -512,6 +512,12 @@
{
SdTransferable* pDragTransferable = SD_MOD()->pTransferDrag;
if(pDragTransferable && (nDropAction & DND_ACTION_LINK))
{
// suppress own data when it's intention is to use it as fill information
pDragTransferable = 0;
}
if( pDragTransferable )
{
const View* pSourceView = pDragTransferable->GetView();
@@ -581,7 +587,7 @@
}
if( bHasPickObj && !bIsPresTarget &&
( !pPickObj->ISA( SdrGrafObj ) || bGraphic || bMtf || bBitmap || ( bXFillExchange && !pPickObj->ISA( SdrGrafObj ) && !pPickObj->ISA( SdrOle2Obj ) ) ) )
( bGraphic || bMtf || bBitmap || bXFillExchange ) )
{
if( mpDropMarkerObj != pPickObj )
{
diff --git a/sd/source/ui/view/sdview3.cxx b/sd/source/ui/view/sdview3.cxx
index ab2cfec2..cdbe0aeb 100644
--- a/sd/source/ui/view/sdview3.cxx
+++ b/sd/source/ui/view/sdview3.cxx
@@ -265,7 +265,7 @@
SdrObject* pPickObj = NULL;
SdPage* pPage = NULL;
ImageMap* pImageMap = NULL;
sal_Bool bReturn = sal_False;
bool bReturn = false;
sal_Bool bLink = ( ( mnAction & DND_ACTION_LINK ) != 0 );
sal_Bool bCopy = ( ( ( mnAction & DND_ACTION_COPY ) != 0 ) || bLink );
sal_uLong nPasteOptions = SDRINSERT_SETDEFLAYER;
@@ -291,6 +291,12 @@
SdTransferable* pOwnData = NULL;
SdTransferable* pImplementation = SdTransferable::getImplementation( aDataHelper.GetTransferable() );
if(pImplementation && (rDnDAction & DND_ACTION_LINK))
{
// suppress own data when it's intention is to use it as fill information
pImplementation = 0;
}
// try to get own transfer data
if( pImplementation )
{
@@ -343,11 +349,14 @@
}
}
// Changed the whole decision tree to be dependent of bReturn as a flag that
// the work was done; this allows to check multiple formats and not just fail
// when a CHECK_FORMAT_TRANS(*format*) detected format does not work. This is
// e.g. necessary for FORMAT_BITMAP
if( pOwnData && !nFormat )
{
const View* pSourceView = pOwnData->GetView();
if( pOwnData->GetDocShell() && pOwnData->IsPageTransferable() && ISA( View ) )
{
mpClipboard->HandlePageDrop (*pOwnData);
@@ -389,7 +398,7 @@
}
}
bReturn = sal_True;
bReturn = true;
}
}
else
@@ -565,12 +574,12 @@
if( pMarkList != mpDragSrcMarkList )
delete pMarkList;
bReturn = sal_True;
bReturn = true;
}
else
{
maDropErrorTimer.Start();
bReturn = sal_False;
bReturn = false;
}
}
}
@@ -579,7 +588,7 @@
pOwnData->SetInternalMove( sal_True );
MoveAllMarked( Size( maDropPos.X() - pOwnData->GetStartPos().X(),
maDropPos.Y() - pOwnData->GetStartPos().Y() ), bCopy );
bReturn = sal_True;
bReturn = true;
}
}
}
@@ -605,7 +614,7 @@
else
{
maDropErrorTimer.Start();
bReturn = sal_False;
bReturn = false;
}
}
}
@@ -641,7 +650,8 @@
pPage->SetPresentationLayout( aLayout, sal_False, sal_False );
}
}
else if( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_DRAWING ) )
if(!bReturn && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_DRAWING ))
{
SotStorageStreamRef xStm;
@@ -794,7 +804,8 @@
}
}
}
else if( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE ) )
if(!bReturn && CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_SBA_FIELDDATAEXCHANGE))
{
OUString aOUString;
@@ -813,14 +824,15 @@
aRect.SetPos( maDropPos );
pObj->SetLogicRect( aRect );
InsertObjectAtView( pObj, *GetSdrPageView(), SDRINSERT_SETDEFLAYER );
bReturn = sal_True;
bReturn = true;
}
}
}
else if( !bLink &&
( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBED_SOURCE ) ||
CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBEDDED_OBJ ) ) &&
aDataHelper.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR ) )
if(!bReturn &&
!bLink &&
(CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_EMBED_SOURCE) || CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_EMBEDDED_OBJ)) &&
aDataHelper.HasFormat(SOT_FORMATSTR_ID_OBJECTDESCRIPTOR))
{
//TODO/LATER: is it possible that this format is binary?! (from old versions of SO)
uno::Reference < io::XInputStream > xStm;
@@ -987,15 +999,16 @@
}
}
bReturn = sal_True;
bReturn = true;
}
}
}
}
else if( !bLink &&
( CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE ) ||
CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EMBED_SOURCE_OLE ) ) &&
aDataHelper.HasFormat( SOT_FORMATSTR_ID_OBJECTDESCRIPTOR_OLE ) )
if(!bReturn &&
!bLink &&
(CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_EMBEDDED_OBJ_OLE) || CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_EMBED_SOURCE_OLE)) &&
aDataHelper.HasFormat(SOT_FORMATSTR_ID_OBJECTDESCRIPTOR_OLE))
{
// online insert ole if format is forced or no gdi metafile is available
if( (nFormat != 0) || !aDataHelper.HasFormat( FORMAT_GDIMETAFILE ) )
@@ -1136,7 +1149,7 @@
// let the object stay in loaded state after insertion
pObj->Unload();
bReturn = sal_True;
bReturn = true;
}
}
}
@@ -1148,7 +1161,8 @@
bReturn = true;
}
}
else if( ( !bLink || pPickObj ) && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_SVXB ) )
if(!bReturn && (!bLink || pPickObj) && CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_SVXB))
{
SotStorageStreamRef xStm;
@@ -1182,10 +1196,11 @@
ImpCheckInsertPos(aInsertPos, aImageMapSize, GetWorkArea());
InsertGraphic( aGraphic, mnAction, aInsertPos, NULL, pImageMap );
bReturn = sal_True;
bReturn = true;
}
}
else if( ( !bLink || pPickObj ) && CHECK_FORMAT_TRANS( FORMAT_GDIMETAFILE ) )
if(!bReturn && (!bLink || pPickObj) && CHECK_FORMAT_TRANS(FORMAT_GDIMETAFILE))
{
Point aInsertPos( rPos );
@@ -1208,7 +1223,8 @@
bReturn = InsertMetaFile( aDataHelper, aInsertPos, pImageMap, nFormat == 0 ? true : false ) ? sal_True : sal_False;
}
else if( ( !bLink || pPickObj ) && CHECK_FORMAT_TRANS( FORMAT_BITMAP ) )
if(!bReturn && (!bLink || pPickObj) && CHECK_FORMAT_TRANS(FORMAT_BITMAP))
{
BitmapEx aBmpEx;
@@ -1259,10 +1275,11 @@
ImpCheckInsertPos(aInsertPos, aImageMapSize, GetWorkArea());
InsertGraphic( aBmpEx, mnAction, aInsertPos, NULL, pImageMap );
bReturn = sal_True;
bReturn = true;
}
}
else if( pPickObj && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_XFA ) )
if(!bReturn && pPickObj && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_XFA ) )
{
SotStorageStreamRef xStm;
@@ -1325,7 +1342,8 @@
}
}
}
else if( !bLink && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_HTML ) )
if(!bReturn && !bLink && CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_HTML))
{
SotStorageStreamRef xStm;
@@ -1336,7 +1354,8 @@
bReturn = SdrView::Paste( *xStm, String(), EE_FORMAT_HTML, maDropPos, pPage, nPasteOptions );
}
}
else if( !bLink && CHECK_FORMAT_TRANS( SOT_FORMATSTR_ID_EDITENGINE ) )
if(!bReturn && !bLink && CHECK_FORMAT_TRANS(SOT_FORMATSTR_ID_EDITENGINE))
{
SotStorageStreamRef xStm;
@@ -1355,7 +1374,7 @@
{
// mba: clipboard always must contain absolute URLs (could be from alien source)
pOLV->Read( *xStm, String(), EE_FORMAT_BIN, sal_False, mpDocSh->GetHeaderAttributes() );
bReturn = sal_True;
bReturn = true;
}
}
@@ -1364,7 +1383,8 @@
bReturn = SdrView::Paste( *xStm, String(), EE_FORMAT_BIN, maDropPos, pPage, nPasteOptions );
}
}
else if( !bLink && CHECK_FORMAT_TRANS( FORMAT_RTF ) )
if(!bReturn && !bLink && CHECK_FORMAT_TRANS(FORMAT_RTF))
{
SotStorageStreamRef xStm;
@@ -1389,7 +1409,7 @@
{
// mba: clipboard always must contain absolute URLs (could be from alien source)
pOLV->Read( *xStm, String(), EE_FORMAT_RTF, sal_False, mpDocSh->GetHeaderAttributes() );
bReturn = sal_True;
bReturn = true;
}
}
@@ -1399,7 +1419,8 @@
}
}
}
else if( CHECK_FORMAT_TRANS( FORMAT_FILE_LIST ) )
if(!bReturn && CHECK_FORMAT_TRANS(FORMAT_FILE_LIST))
{
FileList aDropFileList;
@@ -1413,9 +1434,10 @@
maDropInsertFileTimer.Start();
}
bReturn = sal_True;
bReturn = true;
}
else if( CHECK_FORMAT_TRANS( FORMAT_FILE ) )
if(!bReturn && CHECK_FORMAT_TRANS(FORMAT_FILE))
{
String aDropFile;
@@ -1426,9 +1448,10 @@
maDropInsertFileTimer.Start();
}
bReturn = sal_True;
bReturn = true;
}
else if( !bLink && CHECK_FORMAT_TRANS( FORMAT_STRING ) )
if(!bReturn && !bLink && CHECK_FORMAT_TRANS(FORMAT_STRING))
{
if( ( FORMAT_STRING == nFormat ) ||
( !aDataHelper.HasFormat( SOT_FORMATSTR_ID_SOLK ) &&
@@ -1444,7 +1467,7 @@
if( pOLV )
{
pOLV->InsertText( aOUString );
bReturn = sal_True;
bReturn = true;
}
if( !bReturn )
diff --git a/svx/Library_svxcore.mk b/svx/Library_svxcore.mk
index 21a03bf..30a33a4 100644
--- a/svx/Library_svxcore.mk
+++ b/svx/Library_svxcore.mk
@@ -196,7 +196,7 @@
svx/source/sdr/overlay/overlayrollingrectangle \
svx/source/sdr/overlay/overlaytriangle \
svx/source/sdr/overlay/overlayselection \
svx/source/sdr/overlay/overlayhatchrect \
svx/source/sdr/overlay/overlayrectangle \
svx/source/sdr/overlay/overlaybitmapex \
svx/source/sdr/overlay/overlaymanagerbuffered \
svx/source/sdr/overlay/overlayhelpline \
diff --git a/svx/source/engine3d/dragmt3d.cxx b/svx/source/engine3d/dragmt3d.cxx
index ccc796e..4e0bf86 100644
--- a/svx/source/engine3d/dragmt3d.cxx
+++ b/svx/source/engine3d/dragmt3d.cxx
@@ -259,7 +259,8 @@
if(aResult.count())
{
::sdr::overlay::OverlayPolyPolygonStriped* pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(aResult);
::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
aResult);
rOverlayManager.add(*pNew);
addToOverlayObjectList(*pNew);
}
diff --git a/svx/source/engine3d/view3d.cxx b/svx/source/engine3d/view3d.cxx
index 5f856ed..15a4787 100644
--- a/svx/source/engine3d/view3d.cxx
+++ b/svx/source/engine3d/view3d.cxx
@@ -213,7 +213,8 @@
basegfx::B2DPolyPolygon aPolyPolygon(mpPolygons[b]);
aPolyPolygon.transform(aMatrixTransform);
::sdr::overlay::OverlayPolyPolygonStriped* pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(aPolyPolygon);
::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
aPolyPolygon);
xTargetOverlay->add(*pNew);
maObjects.append(*pNew);
}
diff --git a/svx/source/sdr/overlay/overlayanimatedbitmapex.cxx b/svx/source/sdr/overlay/overlayanimatedbitmapex.cxx
index cf9d584..ff4d97b 100644
--- a/svx/source/sdr/overlay/overlayanimatedbitmapex.cxx
+++ b/svx/source/sdr/overlay/overlayanimatedbitmapex.cxx
@@ -29,19 +29,6 @@
{
namespace overlay
{
// #i53216# check blink time value range
void OverlayAnimatedBitmapEx::impCheckBlinkTimeValueRange()
{
if(mnBlinkTime < 25)
{
mnBlinkTime = 25;
}
else if(mnBlinkTime > 10000)
{
mnBlinkTime = 10000;
}
}
drawinglayer::primitive2d::Primitive2DSequence OverlayAnimatedBitmapEx::createOverlayObjectPrimitive2DSequence()
{
if(mbOverlayState)
@@ -89,7 +76,7 @@
mbAllowsAnimation = true;
// #i53216# check blink time value range
impCheckBlinkTimeValueRange();
mnBlinkTime = impCheckBlinkTimeValueRange(mnBlinkTime);
}
OverlayAnimatedBitmapEx::~OverlayAnimatedBitmapEx()
diff --git a/svx/source/sdr/overlay/overlayhatchrect.cxx b/svx/source/sdr/overlay/overlayhatchrect.cxx
deleted file mode 100644
index 2b6c7e1..0000000
--- a/svx/source/sdr/overlay/overlayhatchrect.cxx
+++ /dev/null
@@ -1,71 +0,0 @@
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <svx/sdr/overlay/overlayhatchrect.hxx>
#include <vcl/hatch.hxx>
#include <vcl/outdev.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/numeric/ftools.hxx>
#include <svx/sdr/overlay/overlaytools.hxx>
//////////////////////////////////////////////////////////////////////////////
namespace sdr
{
namespace overlay
{
drawinglayer::primitive2d::Primitive2DSequence OverlayHatchRect::createOverlayObjectPrimitive2DSequence()
{
const basegfx::B2DRange aHatchRange(getBasePosition(), getSecondPosition());
const drawinglayer::primitive2d::Primitive2DReference aReference(
new drawinglayer::primitive2d::OverlayHatchRectanglePrimitive(
aHatchRange,
3.0,
getHatchRotation(),
getBaseColor().getBColor(),
getDiscreteGrow(),
getDiscreteShrink(),
getRotation()));
return drawinglayer::primitive2d::Primitive2DSequence(&aReference, 1);
}
OverlayHatchRect::OverlayHatchRect(
const basegfx::B2DPoint& rBasePosition,
const basegfx::B2DPoint& rSecondPosition,
const Color& rHatchColor,
double fDiscreteGrow,
double fDiscreteShrink,
double fHatchRotation,
double fRotation)
: OverlayObjectWithBasePosition(rBasePosition, rHatchColor),
maSecondPosition(rSecondPosition),
mfDiscreteGrow(fDiscreteGrow),
mfDiscreteShrink(fDiscreteShrink),
mfHatchRotation(fHatchRotation),
mfRotation(fRotation)
{
}
} // end of namespace overlay
} // end of namespace sdr
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/svx/source/sdr/overlay/overlaymanager.cxx b/svx/source/sdr/overlay/overlaymanager.cxx
index 818bfc6..d9a0ef4 100644
--- a/svx/source/sdr/overlay/overlaymanager.cxx
+++ b/svx/source/sdr/overlay/overlaymanager.cxx
@@ -157,8 +157,14 @@
if(OUTDEV_WINDOW == getOutputDevice().GetOutDevType())
{
const Size aOutputSizePixel(getOutputDevice().GetOutputSizePixel());
aViewRange = basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight());
aViewRange.transform(getOutputDevice().GetInverseViewTransformation());
// only set when we *have* a output size, else let aViewRange
// stay on empty
if(aOutputSizePixel.Width() && aOutputSizePixel.Height())
{
aViewRange = basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight());
aViewRange.transform(getOutputDevice().GetInverseViewTransformation());
}
}
OverlayManager* pThis = const_cast< OverlayManager* >(this);
diff --git a/svx/source/sdr/overlay/overlayobject.cxx b/svx/source/sdr/overlay/overlayobject.cxx
index da15079..292cb5a 100644
--- a/svx/source/sdr/overlay/overlayobject.cxx
+++ b/svx/source/sdr/overlay/overlayobject.cxx
@@ -63,6 +63,20 @@
return drawinglayer::primitive2d::Primitive2DSequence();
}
sal_uInt32 OverlayObject::impCheckBlinkTimeValueRange(sal_uInt32 nBlinkTime) const
{
if(nBlinkTime < 25)
{
nBlinkTime = 25;
}
else if(nBlinkTime > 10000)
{
nBlinkTime = 10000;
}
return nBlinkTime;
}
void OverlayObject::allowAntiAliase(bool bNew)
{
if(bNew != (bool)mbAllowsAntiAliase)
diff --git a/svx/source/sdr/overlay/overlaypolypolygon.cxx b/svx/source/sdr/overlay/overlaypolypolygon.cxx
index e1b0646..f85021c 100644
--- a/svx/source/sdr/overlay/overlaypolypolygon.cxx
+++ b/svx/source/sdr/overlay/overlaypolypolygon.cxx
@@ -30,7 +30,7 @@
{
namespace overlay
{
drawinglayer::primitive2d::Primitive2DSequence OverlayPolyPolygonStriped::createOverlayObjectPrimitive2DSequence()
drawinglayer::primitive2d::Primitive2DSequence OverlayPolyPolygonStripedAndFilled::createOverlayObjectPrimitive2DSequence()
{
drawinglayer::primitive2d::Primitive2DSequence aRetval;
@@ -39,34 +39,47 @@
const basegfx::BColor aRGBColorA(getOverlayManager()->getStripeColorA().getBColor());
const basegfx::BColor aRGBColorB(getOverlayManager()->getStripeColorB().getBColor());
const double fStripeLengthPixel(getOverlayManager()->getStripeLengthPixel());
const drawinglayer::primitive2d::Primitive2DReference aReference(
const drawinglayer::primitive2d::Primitive2DReference aStriped(
new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D(
getPolyPolygon(),
getLinePolyPolygon(),
aRGBColorA,
aRGBColorB,
fStripeLengthPixel));
aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aReference, 1);
aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aStriped, 1);
const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
const basegfx::BColor aHilightColor(aSvtOptionsDrawinglayer.getHilightColor().getBColor());
const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
const drawinglayer::primitive2d::Primitive2DReference aFilled(
new drawinglayer::primitive2d::PolyPolygonSelectionPrimitive2D(
getLinePolyPolygon(),
aHilightColor,
fTransparence,
3.0,
false));
drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, aFilled);
}
return aRetval;
}
void OverlayPolyPolygonStriped::stripeDefinitionHasChanged()
void OverlayPolyPolygonStripedAndFilled::stripeDefinitionHasChanged()
{
// react on OverlayManager's stripe definition change
objectChange();
}
OverlayPolyPolygonStriped::OverlayPolyPolygonStriped(
const basegfx::B2DPolyPolygon& rPolyPolygon)
OverlayPolyPolygonStripedAndFilled::OverlayPolyPolygonStripedAndFilled(
const basegfx::B2DPolyPolygon& rLinePolyPolygon)
: OverlayObject(Color(COL_BLACK)),
maPolyPolygon(rPolyPolygon)
maLinePolyPolygon(rLinePolyPolygon)
{
}
OverlayPolyPolygonStriped::~OverlayPolyPolygonStriped()
OverlayPolyPolygonStripedAndFilled::~OverlayPolyPolygonStripedAndFilled()
{
}
} // end of namespace overlay
diff --git a/svx/source/sdr/overlay/overlayrectangle.cxx b/svx/source/sdr/overlay/overlayrectangle.cxx
new file mode 100644
index 0000000..7f07be0
--- /dev/null
+++ b/svx/source/sdr/overlay/overlayrectangle.cxx
@@ -0,0 +1,150 @@
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <svx/sdr/overlay/overlayrectangle.hxx>
#include <vcl/outdev.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <basegfx/numeric/ftools.hxx>
#include <svx/sdr/overlay/overlaytools.hxx>
#include <svx/sdr/overlay/overlaymanager.hxx>
#include <vcl/svapp.hxx>
//////////////////////////////////////////////////////////////////////////////
namespace sdr
{
namespace overlay
{
drawinglayer::primitive2d::Primitive2DSequence OverlayRectangle::createOverlayObjectPrimitive2DSequence()
{
const basegfx::B2DRange aHatchRange(getBasePosition(), getSecondPosition());
basegfx::BColor aColor(getBaseColor().getBColor());
static double fChange(0.1); // just small optical change, do not make it annoying
if(mbOverlayState)
{
aColor += basegfx::B3DTuple(fChange, fChange, fChange);
aColor.clamp();
}
else
{
aColor -= basegfx::B3DTuple(fChange, fChange, fChange);
aColor.clamp();
}
const drawinglayer::primitive2d::Primitive2DReference aReference(
new drawinglayer::primitive2d::OverlayRectanglePrimitive(
aHatchRange,
aColor,
getTransparence(),
getDiscreteGrow(),
getDiscreteShrink(),
getRotation()));
return drawinglayer::primitive2d::Primitive2DSequence(&aReference, 1);
}
OverlayRectangle::OverlayRectangle(
const basegfx::B2DPoint& rBasePosition,
const basegfx::B2DPoint& rSecondPosition,
const Color& rHatchColor,
double fTransparence,
double fDiscreteGrow,
double fDiscreteShrink,
double fRotation,
sal_uInt32 nBlinkTime,
bool bAnimate)
: OverlayObjectWithBasePosition(rBasePosition, rHatchColor),
maSecondPosition(rSecondPosition),
mfTransparence(fTransparence),
mfDiscreteGrow(fDiscreteGrow),
mfDiscreteShrink(fDiscreteShrink),
mfRotation(fRotation),
mnBlinkTime(nBlinkTime),
mbOverlayState(false)
{
if(Application::GetSettings().GetStyleSettings().GetHighContrastMode())
{
// no animation in high contrast mode
bAnimate = false;
}
// set AllowsAnimation flag to mark this object as animation capable
mbAllowsAnimation = bAnimate;
// #i53216# check blink time value range
mnBlinkTime = impCheckBlinkTimeValueRange(mnBlinkTime);
}
void OverlayRectangle::setSecondPosition(const basegfx::B2DPoint& rNew)
{
if(rNew != maSecondPosition)
{
// remember new value
maSecondPosition = rNew;
// register change (after change)
objectChange();
}
}
void OverlayRectangle::setBlinkTime(sal_uInt32 nNew)
{
if(mnBlinkTime != nNew)
{
// remember new value
mnBlinkTime = nNew;
// #i53216# check blink time value range
mnBlinkTime = impCheckBlinkTimeValueRange(mnBlinkTime);
// register change (after change)
objectChange();
}
}
void OverlayRectangle::Trigger(sal_uInt32 nTime)
{
if(getOverlayManager())
{
// #i53216# produce event after nTime + x
SetTime(nTime + mnBlinkTime);
// switch state
if(mbOverlayState)
{
mbOverlayState = false;
}
else
{
mbOverlayState = true;
}
// re-insert me as event
getOverlayManager()->InsertEvent(this);
// register change (after change)
objectChange();
}
}
} // end of namespace overlay
} // end of namespace sdr
//////////////////////////////////////////////////////////////////////////////
diff --git a/svx/source/sdr/overlay/overlayrollingrectangle.cxx b/svx/source/sdr/overlay/overlayrollingrectangle.cxx
index 977c91e..496cec8 100644
--- a/svx/source/sdr/overlay/overlayrollingrectangle.cxx
+++ b/svx/source/sdr/overlay/overlayrollingrectangle.cxx
@@ -24,7 +24,7 @@
#include <svx/sdr/overlay/overlaymanager.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
//////////////////////////////////////////////////////////////////////////////
@@ -47,14 +47,24 @@
{
// view-independent part, create directly
const basegfx::B2DPolygon aPolygon(basegfx::tools::createPolygonFromRect(aRollingRectangle));
const drawinglayer::primitive2d::Primitive2DReference aReference(
new drawinglayer::primitive2d::PolygonMarkerPrimitive2D(
aPolygon,
aRGBColorA,
aRGBColorB,
fStripeLengthPixel));
drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, aReference);
aRetval.realloc(2);
aRetval[0] = new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D(
basegfx::B2DPolyPolygon(aPolygon),
aRGBColorA,
aRGBColorB,
fStripeLengthPixel);
const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
const basegfx::BColor aHilightColor(aSvtOptionsDrawinglayer.getHilightColor().getBColor());
const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
aRetval[1] = new drawinglayer::primitive2d::PolyPolygonSelectionPrimitive2D(
basegfx::B2DPolyPolygon(aPolygon),
aHilightColor,
fTransparence,
3.0,
false);
}
if(getExtendedLines())
diff --git a/svx/source/sdr/overlay/overlaytools.cxx b/svx/source/sdr/overlay/overlaytools.cxx
index 92e0ff5..d3ae3f9 100644
--- a/svx/source/sdr/overlay/overlaytools.cxx
+++ b/svx/source/sdr/overlay/overlaytools.cxx
@@ -28,6 +28,8 @@
#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
#include <drawinglayer/geometry/viewinformation2d.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include <drawinglayer/primitive2d/unifiedtransparenceprimitive2d.hxx>
#include <vcl/svapp.hxx>
//////////////////////////////////////////////////////////////////////////////
@@ -178,82 +180,121 @@
{
namespace primitive2d
{
OverlayHatchRectanglePrimitive::OverlayHatchRectanglePrimitive(
OverlayRectanglePrimitive::OverlayRectanglePrimitive(
const basegfx::B2DRange& rObjectRange,
double fDiscreteHatchDistance,
double fHatchRotation,
const basegfx::BColor& rHatchColor,
const basegfx::BColor& rColor,
double fTransparence,
double fDiscreteGrow,
double fDiscreteShrink,
double fRotation)
: DiscreteMetricDependentPrimitive2D(),
maObjectRange(rObjectRange),
mfDiscreteHatchDistance(fDiscreteHatchDistance),
mfHatchRotation(fHatchRotation),
maHatchColor(rHatchColor),
maColor(rColor),
mfTransparence(fTransparence),
mfDiscreteGrow(fDiscreteGrow),
mfDiscreteShrink(fDiscreteShrink),
mfRotation(fRotation)
{}
Primitive2DSequence OverlayHatchRectanglePrimitive::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
Primitive2DSequence OverlayRectanglePrimitive::create2DDecomposition(const geometry::ViewInformation2D& /*rViewInformation*/) const
{
Primitive2DSequence aRetval;
basegfx::B2DRange aInnerRange(getObjectRange());
if(basegfx::fTools::more(getDiscreteUnit(), 0.0))
if(!aInnerRange.isEmpty() && basegfx::fTools::more(getDiscreteUnit(), 0.0) && getTransparence() <= 1.0)
{
basegfx::B2DRange aInnerRange(getObjectRange());
basegfx::B2DRange aOuterRange(getObjectRange());
basegfx::B2DPolyPolygon aHatchPolyPolygon;
// grow/shrink inner/outer polygons
aOuterRange.grow(getDiscreteUnit() * getDiscreteGrow());
aInnerRange.grow(getDiscreteUnit() * -getDiscreteShrink());
aHatchPolyPolygon.append(basegfx::tools::createPolygonFromRect(aOuterRange));
// convert to polygons
const double fFullGrow(getDiscreteGrow() + getDiscreteShrink());
const double fRelativeRadiusX(fFullGrow / aOuterRange.getWidth());
const double fRelativeRadiusY(fFullGrow / aOuterRange.getHeight());
basegfx::B2DPolygon aOuterPolygon(
basegfx::tools::createPolygonFromRect(
aOuterRange,
fRelativeRadiusX,
fRelativeRadiusY));
basegfx::B2DPolygon aInnerPolygon(
basegfx::tools::createPolygonFromRect(
aInnerRange));
if(!aInnerRange.isEmpty())
{
aHatchPolyPolygon.append(basegfx::tools::createPolygonFromRect(aInnerRange));
}
// apply evtl. existing rotation
if(!basegfx::fTools::equalZero(getRotation()))
{
const basegfx::B2DHomMatrix aTransform(basegfx::tools::createRotateAroundPoint(
getObjectRange().getMinX(), getObjectRange().getMinY(), getRotation()));
aHatchPolyPolygon.transform(aTransform);
aOuterPolygon.transform(aTransform);
aInnerPolygon.transform(aTransform);
}
const basegfx::BColor aEmptyColor(0.0, 0.0, 0.0);
const drawinglayer::attribute::FillHatchAttribute aFillHatchAttribute(
drawinglayer::attribute::HATCHSTYLE_SINGLE,
getDiscreteHatchDistance() * getDiscreteUnit(),
getHatchRotation() - getRotation(),
getHatchColor(),
3, // same default as VCL, a minimum of three discrete units (pixels) offset
false);
const Primitive2DReference aPrimitive(
new PolyPolygonHatchPrimitive2D(
aHatchPolyPolygon,
aEmptyColor,
aFillHatchAttribute));
// create filled primitive
basegfx::B2DPolyPolygon aPolyPolygon;
aRetval = Primitive2DSequence(&aPrimitive, 1);
aPolyPolygon.append(aOuterPolygon);
aPolyPolygon.append(aInnerPolygon);
if(Application::GetSettings().GetStyleSettings().GetHighContrastMode())
{
// for high contrast, use hatch
const basegfx::BColor aHighContrastLineColor(Application::GetSettings().GetStyleSettings().GetFontColor().getBColor());
const basegfx::BColor aEmptyColor(0.0, 0.0, 0.0);
const double fHatchRotation(45 * F_PI180);
const double fDiscreteHatchDistance(3.0);
const drawinglayer::attribute::FillHatchAttribute aFillHatchAttribute(
drawinglayer::attribute::HATCHSTYLE_SINGLE,
fDiscreteHatchDistance * getDiscreteUnit(),
fHatchRotation - getRotation(),
aHighContrastLineColor,
3, // same default as VCL, a minimum of three discrete units (pixels) offset
false);
const Primitive2DReference aHatch(
new PolyPolygonHatchPrimitive2D(
aPolyPolygon,
aEmptyColor,
aFillHatchAttribute));
aRetval = Primitive2DSequence(&aHatch, 1);
}
else
{
// create fill primitive
const Primitive2DReference aFill(
new PolyPolygonColorPrimitive2D(
aPolyPolygon,
getColor()));
aRetval = Primitive2DSequence(&aFill, 1);
// embed filled to transparency (if used)
if(getTransparence() > 0.0)
{
const Primitive2DReference aFillTransparent(
new UnifiedTransparencePrimitive2D(
aRetval,
getTransparence()));
aRetval = Primitive2DSequence(&aFillTransparent, 1);
}
}
}
return aRetval;
}
bool OverlayHatchRectanglePrimitive::operator==( const BasePrimitive2D& rPrimitive ) const
bool OverlayRectanglePrimitive::operator==( const BasePrimitive2D& rPrimitive ) const
{
if(DiscreteMetricDependentPrimitive2D::operator==(rPrimitive))
{
const OverlayHatchRectanglePrimitive& rCompare = static_cast< const OverlayHatchRectanglePrimitive& >(rPrimitive);
const OverlayRectanglePrimitive& rCompare = static_cast< const OverlayRectanglePrimitive& >(rPrimitive);
return (getObjectRange() == rCompare.getObjectRange()
&& getDiscreteHatchDistance() == rCompare.getDiscreteHatchDistance()
&& getHatchRotation() == rCompare.getHatchRotation()
&& getHatchColor() == rCompare.getHatchColor()
&& getColor() == rCompare.getColor()
&& getTransparence() == rCompare.getTransparence()
&& getDiscreteGrow() == rCompare.getDiscreteGrow()
&& getDiscreteShrink() == rCompare.getDiscreteShrink()
&& getRotation() == rCompare.getRotation());
@@ -262,7 +303,7 @@
return false;
}
ImplPrimitive2DIDBlock(OverlayHatchRectanglePrimitive, PRIMITIVE2D_ID_OVERLAYHATCHRECTANGLEPRIMITIVE)
ImplPrimitive2DIDBlock(OverlayRectanglePrimitive, PRIMITIVE2D_ID_OVERLAYRECTANGLEPRIMITIVE)
} // end of namespace primitive2d
} // end of namespace drawinglayer
diff --git a/svx/source/svdraw/svdcrtv.cxx b/svx/source/svdraw/svdcrtv.cxx
index e6980bd..10bcaed 100644
--- a/svx/source/svdraw/svdcrtv.cxx
+++ b/svx/source/svdraw/svdcrtv.cxx
@@ -73,7 +73,8 @@
Size aHalfLogicSize(xTargetOverlay->getOutputDevice().PixelToLogic(Size(4, 4)));
// object
::sdr::overlay::OverlayPolyPolygonStriped* pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(aB2DPolyPolygon);
::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
aB2DPolyPolygon);
xTargetOverlay->add(*pNew);
maObjects.append(*pNew);
@@ -98,7 +99,8 @@
basegfx::B2DPolyPolygon aTempPolyPoly;
aTempPolyPoly.append(aTempPoly);
pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(aTempPolyPoly);
pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
aTempPolyPoly);
xTargetOverlay->add(*pNew);
maObjects.append(*pNew);
}
@@ -159,7 +161,8 @@
if(rPolyPoly.count())
{
::sdr::overlay::OverlayPolyPolygonStriped* pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(rPolyPoly);
::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
rPolyPoly);
xOverlayManager->add(*pNew);
maObjects.append(*pNew);
}
diff --git a/svx/source/svdraw/svddrgmt.cxx b/svx/source/svdraw/svddrgmt.cxx
index d79d5f2..2255d58 100644
--- a/svx/source/svdraw/svddrgmt.cxx
+++ b/svx/source/svdraw/svddrgmt.cxx
@@ -56,6 +56,7 @@
#include <svx/svdopath.hxx>
#include <svx/polypolygoneditor.hxx>
#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/transformprimitive2d.hxx>
#include <drawinglayer/primitive2d/markerarrayprimitive2d.hxx>
#include <svx/sdr/primitive2d/sdrattributecreator.hxx>
@@ -113,10 +114,22 @@
aColB.invert();
}
drawinglayer::primitive2d::Primitive2DReference aPolyPolygonMarkerPrimitive2D(
new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D(aCopy, aColA, aColB, fStripeLength));
aRetval.realloc(2);
aRetval[0] = new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D(
aCopy,
aColA,
aColB,
fStripeLength);
aRetval = drawinglayer::primitive2d::Primitive2DSequence(&aPolyPolygonMarkerPrimitive2D, 1);
const basegfx::BColor aHilightColor(aSvtOptionsDrawinglayer.getHilightColor().getBColor());
const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
aRetval[1] = new drawinglayer::primitive2d::PolyPolygonSelectionPrimitive2D(
aCopy,
aHilightColor,
fTransparence,
3.0,
false);
}
return aRetval;
@@ -936,8 +949,8 @@
}
drawinglayer::primitive2d::Primitive2DReference aPolyPolygonMarkerPrimitive2D(
new drawinglayer::primitive2d::PolyPolygonMarkerPrimitive2D(
basegfx::B2DPolyPolygon(aEdgePolygon), aColA, aColB, fStripeLength));
new drawinglayer::primitive2d::PolygonMarkerPrimitive2D(
aEdgePolygon, aColA, aColB, fStripeLength));
drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(aRetval, aPolyPolygonMarkerPrimitive2D);
}
}
diff --git a/svx/source/svdraw/svdedxv.cxx b/svx/source/svdraw/svdedxv.cxx
index 273480f..492b0a7 100644
--- a/svx/source/svdraw/svdedxv.cxx
+++ b/svx/source/svdraw/svdedxv.cxx
@@ -17,14 +17,10 @@
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <com/sun/star/i18n/WordType.hpp>
#include <svtools/accessibilityoptions.hxx>
#include <svx/svdedxv.hxx>
#include <svl/solar.hrc>
#include <svl/itemiter.hxx>
#include <vcl/msgbox.hxx>
#include <vcl/hatch.hxx>
@@ -33,7 +29,6 @@
#include <editeng/editstat.hxx>
#include <vcl/cursor.hxx>
#include <editeng/unotext.hxx>
#include <editeng/editdata.hxx>
#include <editeng/editeng.hxx>
#include <editeng/editobj.hxx>
@@ -46,24 +41,26 @@
#include "svx/svditer.hxx"
#include "svx/svdpagv.hxx"
#include "svx/svdpage.hxx"
#include "svx/svdetc.hxx" // for GetDraftFillColor
#include "svx/svdetc.hxx"
#include "svx/svdotable.hxx"
#include <svx/selectioncontroller.hxx>
#ifdef DBG_UTIL
#include <svdibrow.hxx>
#endif
#include <svx/svddrgv.hxx> // for SetSolidDragging()
#include "svx/svdstr.hrc" // names taken from the resource
#include "svx/svdglob.hxx" // StringCache
#include <svx/svdoutl.hxx>
#include <svx/svddrgv.hxx>
#include "svx/svdstr.hrc"
#include "svx/svdglob.hxx"
#include "svx/globl3d.hxx"
#include <editeng/outliner.hxx>
#include <editeng/adjustitem.hxx>
#include <svtools/colorcfg.hxx>
#include <vcl/svapp.hxx>
#include <svx/sdrpaintwindow.hxx>
#include <svx/sdrundomanager.hxx>
#include <svx/sdr/overlay/overlaytools.hxx>
#include <drawinglayer/processor2d/baseprocessor2d.hxx>
#include <drawinglayer/processor2d/processorfromoutputdevice.hxx>
////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -344,44 +341,36 @@
if(bTextFrame && !bFitToSize)
{
aPixRect.Left()--;
aPixRect.Top()--;
aPixRect.Right()++;
aPixRect.Bottom()++;
sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
// completely reworked to use primitives; this ensures same look and functionality
const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
drawinglayer::processor2d::BaseProcessor2D* pProcessor = drawinglayer::processor2d::createBaseProcessor2DFromOutputDevice(
rTargetDevice,
aViewInformation2D);
if(pProcessor)
{
// xPixRect Begrenzen, wegen Treiberproblem bei zu weit hinausragenden Pixelkoordinaten
Size aMaxXY(rTargetDevice.GetOutputSizePixel());
long a(2 * nPixSiz);
long nMaxX(aMaxXY.Width() + a);
long nMaxY(aMaxXY.Height() + a);
const bool bMerk(rTargetDevice.IsMapModeEnabled());
const basegfx::B2DRange aRange(aPixRect.Left(), aPixRect.Top(), aPixRect.Right(), aPixRect.Bottom());
const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor());
const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
const sal_uInt16 nPixSiz(rOutlView.GetInvalidateMore() - 1);
const drawinglayer::primitive2d::Primitive2DReference xReference(
new drawinglayer::primitive2d::OverlayRectanglePrimitive(
aRange,
aHilightColor.getBColor(),
fTransparence,
std::max(6, nPixSiz - 2), // grow
0.0, // shrink
0.0));
const drawinglayer::primitive2d::Primitive2DSequence aSequence(&xReference, 1);
if (aPixRect.Left ()<-a) aPixRect.Left()=-a;
if (aPixRect.Top ()<-a) aPixRect.Top ()=-a;
if (aPixRect.Right ()>nMaxX) aPixRect.Right ()=nMaxX;
if (aPixRect.Bottom()>nMaxY) aPixRect.Bottom()=nMaxY;
rTargetDevice.EnableMapMode(false);
pProcessor->process(aSequence);
rTargetDevice.EnableMapMode(bMerk);
delete pProcessor;
}
Rectangle aOuterPix(aPixRect);
aOuterPix.Left()-=nPixSiz;
aOuterPix.Top()-=nPixSiz;
aOuterPix.Right()+=nPixSiz;
aOuterPix.Bottom()+=nPixSiz;
bool bMerk(rTargetDevice.IsMapModeEnabled());
rTargetDevice.EnableMapMode(sal_False);
PolyPolygon aPolyPoly( 2 );
svtools::ColorConfig aColorConfig;
Color aHatchCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
const Hatch aHatch( HATCH_SINGLE, aHatchCol, 3, 450 );
aPolyPoly.Insert( aOuterPix );
aPolyPoly.Insert( aPixRect );
rTargetDevice.DrawHatch( aPolyPoly, aHatch );
rTargetDevice.EnableMapMode(bMerk);
}
rOutlView.ShowCursor();
diff --git a/svx/source/svdraw/svdhdl.cxx b/svx/source/svdraw/svdhdl.cxx
index fa7dc52..5a03983 100644
--- a/svx/source/svdraw/svdhdl.cxx
+++ b/svx/source/svdraw/svdhdl.cxx
@@ -50,7 +50,7 @@
#include <svx/sdr/overlay/overlaybitmapex.hxx>
#include <svx/sdr/overlay/overlayline.hxx>
#include <svx/sdr/overlay/overlaytriangle.hxx>
#include <svx/sdr/overlay/overlayhatchrect.hxx>
#include <svx/sdr/overlay/overlayrectangle.hxx>
#include <svx/sdrpagewindow.hxx>
#include <svx/sdrpaintwindow.hxx>
#include <vcl/svapp.hxx>
@@ -1402,7 +1402,8 @@
if (xManager.is() && aWireframePoly.count())
{
::sdr::overlay::OverlayObject* pNewOverlayObject = new
::sdr::overlay::OverlayPolyPolygonStriped(aWireframePoly);
::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
aWireframePoly);
DBG_ASSERT(pNewOverlayObject, "Got NO new IAO!");
// OVERLAYMANAGER
@@ -1654,17 +1655,21 @@
{
const basegfx::B2DPoint aTopLeft(maRect.Left(), maRect.Top());
const basegfx::B2DPoint aBottomRight(maRect.Right(), maRect.Bottom());
const svtools::ColorConfig aColorConfig;
const Color aHatchCol( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor());
const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
::sdr::overlay::OverlayHatchRect* pNewOverlayObject = new ::sdr::overlay::OverlayHatchRect(
::sdr::overlay::OverlayRectangle* pNewOverlayObject = new ::sdr::overlay::OverlayRectangle(
aTopLeft,
aBottomRight,
aHatchCol,
aHilightColor,
fTransparence,
3.0,
3.0,
45 * F_PI180,
nDrehWink * -F_PI18000);
nDrehWink * -F_PI18000,
500,
true); // allow animation; the Handle is not shown at text edit time
pNewOverlayObject->setHittable(false);
// OVERLAYMANAGER
diff --git a/svx/source/svdraw/svdobj.cxx b/svx/source/svdraw/svdobj.cxx
index 98e3b9a..6930128 100644
--- a/svx/source/svdraw/svdobj.cxx
+++ b/svx/source/svdraw/svdobj.cxx
@@ -2416,6 +2416,33 @@
////////////////////////////////////////////////////////////////////////////////////////////////////
void extractLineContourFromPrimitive2DSequence(
const drawinglayer::primitive2d::Primitive2DSequence& rxSequence,
basegfx::B2DPolygonVector& rExtractedHairlines,
basegfx::B2DPolyPolygonVector& rExtractedLineFills)
{
rExtractedHairlines.clear();
rExtractedLineFills.clear();
if(rxSequence.hasElements())
{
// use neutral ViewInformation
const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
// create extractor, process and get result
drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
aExtractor.process(rxSequence);
// copy line results
rExtractedHairlines = aExtractor.getExtractedHairlines();
// copy fill rsults
rExtractedLineFills = aExtractor.getExtractedLineFills();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
SdrObject* SdrObject::ImpConvertToContourObj(SdrObject* pRet, bool bForceLineDash) const
{
bool bNoChange(true);
@@ -2428,37 +2455,28 @@
if(xSequence.hasElements())
{
// use neutral ViewInformation
const drawinglayer::geometry::ViewInformation2D aViewInformation2D;
basegfx::B2DPolygonVector aExtractedHairlines;
basegfx::B2DPolyPolygonVector aExtractedLineFills;
// create extractor, process and get result
drawinglayer::processor2d::LineGeometryExtractor2D aExtractor(aViewInformation2D);
aExtractor.process(xSequence);
extractLineContourFromPrimitive2DSequence(xSequence, aExtractedHairlines, aExtractedLineFills);
// #i102241# check for line results
const basegfx::B2DPolygonVector& rHairlineVector = aExtractor.getExtractedHairlines();
if(!rHairlineVector.empty())
if(!aExtractedHairlines.empty())
{
// for SdrObject creation, just copy all to a single Hairline-PolyPolygon
for(sal_uInt32 a(0); a < rHairlineVector.size(); a++)
for(sal_uInt32 a(0); a < aExtractedHairlines.size(); a++)
{
aMergedHairlinePolyPolygon.append(rHairlineVector[a]);
aMergedHairlinePolyPolygon.append(aExtractedHairlines[a]);
}
}
// #i102241# check for fill rsults
const basegfx::B2DPolyPolygonVector& rLineFillVector(aExtractor.getExtractedLineFills());
if(!rLineFillVector.empty())
// check for fill rsults
if(!aExtractedLineFills.empty())
{
// merge to a single PolyPolygon (OR)
aMergedLineFillPolyPolygon = basegfx::tools::mergeToSinglePolyPolygon(rLineFillVector);
aMergedLineFillPolyPolygon = basegfx::tools::mergeToSinglePolyPolygon(aExtractedLineFills);
}
}
// || aMergedHairlinePolyPolygon.Count() removed; the conversion is ONLY
// useful when new closed filled polygons are created
if(aMergedLineFillPolyPolygon.count() || (bForceLineDash && aMergedHairlinePolyPolygon.count()))
{
SfxItemSet aSet(pRet->GetMergedItemSet());
diff --git a/svx/source/svdraw/svdview.cxx b/svx/source/svdraw/svdview.cxx
index ea1c737..b933860 100644
--- a/svx/source/svdraw/svdview.cxx
+++ b/svx/source/svdraw/svdview.cxx
@@ -47,6 +47,8 @@
#include <svx/sdrpaintwindow.hxx>
#include <svx/sdrpagewindow.hxx>
#include <svx/sdrhittesthelper.hxx>
#include <svx/sdr/contact/viewcontact.hxx>
#include <drawinglayer/processor2d/contourextractor2d.hxx>
////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -89,7 +91,9 @@
////////////////////////////////////////////////////////////////////////////////////////////////////
// helper class for all D&D overlays
void SdrDropMarkerOverlay::ImplCreateOverlays(const SdrView& rView, const basegfx::B2DPolyPolygon& rPolyPolygon)
void SdrDropMarkerOverlay::ImplCreateOverlays(
const SdrView& rView,
const basegfx::B2DPolyPolygon& rLinePolyPolygon)
{
for(sal_uInt32 a(0L); a < rView.PaintWindowCount(); a++)
{
@@ -98,8 +102,9 @@
if (xTargetOverlay.is())
{
::sdr::overlay::OverlayPolyPolygonStriped* pNew = new ::sdr::overlay::OverlayPolyPolygonStriped(
rPolyPolygon);
::sdr::overlay::OverlayPolyPolygonStripedAndFilled* pNew = new ::sdr::overlay::OverlayPolyPolygonStripedAndFilled(
rLinePolyPolygon);
xTargetOverlay->add(*pNew);
maObjects.append(*pNew);
}
@@ -108,35 +113,37 @@
SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const SdrObject& rObject)
{
ImplCreateOverlays(rView, rObject.TakeXorPoly());
ImplCreateOverlays(
rView,
rObject.TakeXorPoly());
}
SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const Rectangle& rRectangle)
{
basegfx::B2DPolygon aB2DPolygon;
aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Top()));
aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Top()));
aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Right(), rRectangle.Bottom()));
aB2DPolygon.append(basegfx::B2DPoint(rRectangle.Left(), rRectangle.Bottom()));
aB2DPolygon.setClosed(true);
basegfx::B2DPolyPolygon aB2DPolyPolygon;
aB2DPolyPolygon.append(aB2DPolygon);
ImplCreateOverlays(rView, aB2DPolyPolygon);
ImplCreateOverlays(
rView,
basegfx::B2DPolyPolygon(aB2DPolygon));
}
SdrDropMarkerOverlay::SdrDropMarkerOverlay(const SdrView& rView, const Point& rStart, const Point& rEnd)
{
basegfx::B2DPolygon aB2DPolygon;
aB2DPolygon.append(basegfx::B2DPoint(rStart.X(), rStart.Y()));
aB2DPolygon.append(basegfx::B2DPoint(rEnd.X(), rEnd.Y()));
aB2DPolygon.setClosed(true);
basegfx::B2DPolyPolygon aB2DPolyPolygon;
aB2DPolyPolygon.append(aB2DPolygon);
ImplCreateOverlays(rView, aB2DPolyPolygon);
ImplCreateOverlays(
rView,
basegfx::B2DPolyPolygon(aB2DPolygon));
}
SdrDropMarkerOverlay::~SdrDropMarkerOverlay()
diff --git a/svx/source/table/svdotable.cxx b/svx/source/table/svdotable.cxx
index bed3988..2148eb9 100644
--- a/svx/source/table/svdotable.cxx
+++ b/svx/source/table/svdotable.cxx
@@ -2215,7 +2215,7 @@
// add remaining handles
SdrHdl* pH=0;
rHdlList.AddHdl( pH = new TableBorderHdl( aRect ) ); pH->SetMoveOutside( true );
rHdlList.AddHdl( pH = new TableBorderHdl( aRect, !IsTextEditActive() ) ); pH->SetMoveOutside( true );
rHdlList.AddHdl( pH = new SdrHdl(aRect.TopLeft(),HDL_UPLFT) ); pH->SetMoveOutside( true );
rHdlList.AddHdl( pH = new SdrHdl(aRect.TopCenter(),HDL_UPPER) ); pH->SetMoveOutside( true );
rHdlList.AddHdl( pH = new SdrHdl(aRect.TopRight(),HDL_UPRGT) ); pH->SetMoveOutside( true );
diff --git a/svx/source/table/tablehandles.cxx b/svx/source/table/tablehandles.cxx
index 07fd729..d6457e7 100644
--- a/svx/source/table/tablehandles.cxx
+++ b/svx/source/table/tablehandles.cxx
@@ -35,7 +35,7 @@
#include <svx/svdmrkv.hxx>
#include <svx/svdpagv.hxx>
#include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
#include <svx/sdr/overlay/overlayhatchrect.hxx>
#include <svx/sdr/overlay/overlayrectangle.hxx>
#include <drawinglayer/primitive2d/hiddengeometryprimitive2d.hxx>
namespace sdr { namespace table {
@@ -246,11 +246,13 @@
// ====================================================================
TableBorderHdl::TableBorderHdl( const Rectangle& rRect )
: SdrHdl( rRect.TopLeft(), HDL_MOVE )
, maRectangle( rRect )
TableBorderHdl::TableBorderHdl(
const Rectangle& rRect,
bool bAnimate)
: SdrHdl(rRect.TopLeft(), HDL_MOVE),
maRectangle(rRect),
mbAnimate(bAnimate)
{
}
Pointer TableBorderHdl::GetPointer() const
@@ -272,7 +274,6 @@
{
for(sal_uInt32 nWindow = 0; nWindow < pPageView->PageWindowCount(); nWindow++)
{
// const SdrPageViewWinRec& rPageViewWinRec = rPageViewWinList[b];
const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(nWindow);
if(rPageWindow.GetPaintWindow().OutputToWindow())
@@ -281,14 +282,24 @@
if (xManager.is())
{
const basegfx::B2DRange aRange(vcl::unotools::b2DRectangleFromRectangle(maRectangle));
sdr::overlay::OverlayObject* pOverlayObject = new sdr::overlay::OverlayHatchRect(
const SvtOptionsDrawinglayer aSvtOptionsDrawinglayer;
const Color aHilightColor(aSvtOptionsDrawinglayer.getHilightColor());
const double fTransparence(aSvtOptionsDrawinglayer.GetTransparentSelectionPercent() * 0.01);
sdr::overlay::OverlayObject* pOverlayObject = new sdr::overlay::OverlayRectangle(
aRange.getMinimum(),
aRange.getMaximum(),
Color(0x80, 0x80, 0x80),
aHilightColor,
fTransparence,
6.0,
0.0,
45 * F_PI180,
0.0);
0.0,
500,
// make animation dependent from text edit active, because for tables
// this handle is also used when text edit *is* active for it. This
// interferes too much concerning repaint stuff (at least as long as
// text edit is not yet on the overlay)
getAnimate());
xManager->add(*pOverlayObject);
maOverlayGroup.append(*pOverlayObject);
diff --git a/svx/source/table/tablehandles.hxx b/svx/source/table/tablehandles.hxx
index 28e2200..b9b745a 100644
--- a/svx/source/table/tablehandles.hxx
+++ b/svx/source/table/tablehandles.hxx
@@ -70,9 +70,12 @@
class TableBorderHdl : public SdrHdl
{
public:
TableBorderHdl( const Rectangle& rRect );
TableBorderHdl(
const Rectangle& rRect,
bool bAnimate);
virtual Pointer GetPointer() const;
bool getAnimate() const { return mbAnimate; }
protected:
// create marker for this kind
@@ -80,6 +83,9 @@
private:
Rectangle maRectangle;
/// bitfield
bool mbAnimate : 1;
};
} // end of namespace table
diff --git a/sw/source/core/frmedt/fecopy.cxx b/sw/source/core/frmedt/fecopy.cxx
index 3fa4a73..a38e0cd 100644
--- a/sw/source/core/frmedt/fecopy.cxx
+++ b/sw/source/core/frmedt/fecopy.cxx
@@ -1452,7 +1452,43 @@
case SW_PASTESDR_SETATTR:
{
SfxItemSet aSet( GetAttrPool() );
aSet.Put(pClpObj->GetMergedItemSet());
const SdrGrafObj* pSdrGrafObj = dynamic_cast< const SdrGrafObj* >(pClpObj);
if(pSdrGrafObj)
{
SdrObject* pTarget = 0;
if(0 != pView->GetMarkedObjectList().GetMarkCount())
{
// try to get target (if it's at least one, take first)
SdrMark* pMark = pView->GetMarkedObjectList().GetMark(0);
if(pMark)
{
pTarget = pMark->GetMarkedSdrObj();
}
}
if(pTarget)
{
// copy ItemSet from target
aSet.Set(pTarget->GetMergedItemSet());
}
// for SdrGrafObj, use the graphic as fill style argument
const Graphic& rGraphic = pSdrGrafObj->GetGraphic();
if(GRAPHIC_NONE != rGraphic.GetType() && GRAPHIC_DEFAULT != rGraphic.GetType())
{
aSet.Put(XFillBitmapItem(String(), rGraphic));
aSet.Put(XFillStyleItem(XFILL_BITMAP));
}
}
else
{
aSet.Put(pClpObj->GetMergedItemSet());
}
pView->SetAttributes( aSet, sal_False );
}
break;
diff --git a/sw/source/ui/dochdl/swdtflvr.cxx b/sw/source/ui/dochdl/swdtflvr.cxx
index 03efaa1..80485bd4 100644
--- a/sw/source/ui/dochdl/swdtflvr.cxx
+++ b/sw/source/ui/dochdl/swdtflvr.cxx
@@ -407,8 +407,13 @@
{
SelectionType nSelectionType = pWrtShell->GetSelectionType();
// SEL_GRF comes from ContentType of editsh
if( (nsSelectionType::SEL_GRF | nsSelectionType::SEL_DRW_FORM) & nSelectionType )
// when pending we will not get the correct type, but nsSelectionType::SEL_TXT
// as fallback. This *happens* durning D&D, so we need to check if we are in
// the fallback and just try to get a graphic
const bool bPending(pWrtShell->BasicActionPend());
// SEL_GRF kommt vom ContentType der editsh
if(bPending || ((nsSelectionType::SEL_GRF | nsSelectionType::SEL_DRW_FORM) & nSelectionType))
{
pClpGraphic = new Graphic;
if( !pWrtShell->GetDrawObjGraphic( FORMAT_GDIMETAFILE, *pClpGraphic ))
@@ -1215,8 +1220,31 @@
SwTransferable *pTrans=0, *pTunneledTrans=GetSwTransferable( rData );
if( pPt && ( bPasteSelection ? 0 != ( pTrans = pMod->pXSelection )
: 0 != ( pTrans = pMod->pDragDrop) ))
// check for private drop
bool bPrivateDrop(pPt && (bPasteSelection ? 0 != (pTrans = pMod->pXSelection) : 0 != (pTrans = pMod->pDragDrop)));
bool bNeedToSelectBeforePaste(false);
if(bPrivateDrop && DND_ACTION_LINK == nDropAction)
{
// internal drop on object, suppress bPrivateDrop to change internal fill
bPrivateDrop = false;
bNeedToSelectBeforePaste = true;
}
if(bPrivateDrop && pPt && DND_ACTION_MOVE == nDropAction)
{
// check if dragged over a useful target. If yes, use as content exchange
// drop as if from external
const SwFrmFmt* pSwFrmFmt = rSh.GetFmtFromObj(*pPt);
if(pSwFrmFmt && 0 != dynamic_cast< const SwDrawFrmFmt* >(pSwFrmFmt))
{
bPrivateDrop = false;
bNeedToSelectBeforePaste = true;
}
}
if(bPrivateDrop)
{
// then internal Drag & Drop or XSelection
nRet = pTrans->PrivateDrop( rSh, *pPt, DND_ACTION_MOVE == nDropAction,
@@ -1267,7 +1295,7 @@
case SOT_FORMATSTR_ID_DRAWING:
nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
SW_PASTESDR_INSERT, pPt,
nActionFlags );
nActionFlags, bNeedToSelectBeforePaste);
break;
case SOT_FORMATSTR_ID_HTML:
@@ -1305,7 +1333,7 @@
case SOT_FORMAT_GDIMETAFILE:
nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
SW_PASTESDR_INSERT,pPt,
nActionFlags, bMsg );
nActionFlags, nDropAction, bNeedToSelectBeforePaste);
break;
case SOT_FORMATSTR_ID_XFORMS:
@@ -1425,7 +1453,7 @@
case SOT_FORMATSTR_ID_DRAWING:
nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
SW_PASTESDR_SETATTR, pPt,
nActionFlags );
nActionFlags, bNeedToSelectBeforePaste);
break;
case SOT_FORMATSTR_ID_SVXB:
case SOT_FORMAT_GDIMETAFILE:
@@ -1436,7 +1464,7 @@
case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR:
nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
SW_PASTESDR_SETATTR, pPt,
nActionFlags, bMsg );
nActionFlags, nDropAction, bNeedToSelectBeforePaste);
break;
default:
OSL_FAIL( "unknown format" );
@@ -1447,7 +1475,7 @@
case EXCHG_OUT_ACTION_INSERT_DRAWOBJ:
nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
SW_PASTESDR_INSERT, pPt,
nActionFlags );
nActionFlags, bNeedToSelectBeforePaste);
break;
case EXCHG_OUT_ACTION_INSERT_SVXB:
case EXCHG_OUT_ACTION_INSERT_GDIMETAFILE:
@@ -1455,13 +1483,13 @@
case EXCHG_OUT_ACTION_INSERT_GRAPH:
nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
SW_PASTESDR_INSERT, pPt,
nActionFlags, bMsg );
nActionFlags, nDropAction, bNeedToSelectBeforePaste);
break;
case EXCHG_OUT_ACTION_REPLACE_DRAWOBJ:
nRet = SwTransferable::_PasteSdrFormat( rData, rSh,
SW_PASTESDR_REPLACE, pPt,
nActionFlags );
nActionFlags, bNeedToSelectBeforePaste);
break;
case EXCHG_OUT_ACTION_REPLACE_SVXB:
@@ -1470,7 +1498,7 @@
case EXCHG_OUT_ACTION_REPLACE_GRAPH:
nRet = SwTransferable::_PasteGrf( rData, rSh, nFormat,
SW_PASTESDR_REPLACE,pPt,
nActionFlags, bMsg );
nActionFlags, nDropAction, bNeedToSelectBeforePaste);
break;
case EXCHG_OUT_ACTION_INSERT_INTERACTIVE:
@@ -2151,13 +2179,21 @@
int SwTransferable::_PasteSdrFormat( TransferableDataHelper& rData,
SwWrtShell& rSh, sal_uInt16 nAction,
const Point* pPt, sal_uInt8 nActionFlags )
const Point* pPt, sal_uInt8 nActionFlags, bool bNeedToSelectBeforePaste)
{
int nRet = 0;
SotStorageStreamRef xStrm;
if( rData.GetSotStorageStream( SOT_FORMATSTR_ID_DRAWING, xStrm ))
{
xStrm->SetVersion( SOFFICE_FILEFORMAT_50 );
if(bNeedToSelectBeforePaste && pPt)
{
// if this is an internal drag, need to set the target right (select it), else
// still the source will be selected
SwTransferable::SetSelInShell( rSh, sal_True, pPt );
}
rSh.Paste( *xStrm, nAction, pPt );
nRet = 1;
@@ -2170,7 +2206,7 @@
int SwTransferable::_PasteGrf( TransferableDataHelper& rData, SwWrtShell& rSh,
sal_uLong nFmt, sal_uInt16 nAction, const Point* pPt,
sal_uInt8 nActionFlags, sal_Bool /*bMsg*/ )
sal_uInt8 nActionFlags, sal_Int8 /* nDropAction */, bool bNeedToSelectBeforePaste)
{
int nRet = 0;
@@ -2185,6 +2221,19 @@
nRet = rData.GetGraphic( nFmt, aGraphic );
break;
case SOT_FORMATSTR_ID_SVXB:
{
SotStorageStreamRef xStm;
if(rData.GetSotStorageStream(SOT_FORMATSTR_ID_SVXB, xStm))
{
*xStm >> aGraphic;
nRet = (GRAPHIC_NONE != aGraphic.GetType() && GRAPHIC_DEFAULT != aGraphic.GetType());
}
break;
}
case SOT_FORMATSTR_ID_NETSCAPE_BOOKMARK:
case SOT_FORMATSTR_ID_FILEGRPDESCRIPTOR:
case SOT_FORMATSTR_ID_UNIFORMRESOURCELOCATOR:
@@ -2237,6 +2286,15 @@
}
}
if(pPt && bNeedToSelectBeforePaste)
{
// when using internal D&Ds, still the source object is selected and
// this is necessary to get the correct source data which is also
// dependent from selection. After receiving the drag data it is
// now tiime to select the correct target object
SwTransferable::SetSelInShell( rSh, sal_True, pPt );
}
if( nRet )
{
//Check and Perform rotation if needed
@@ -2402,10 +2460,10 @@
int SwTransferable::_PasteFileName( TransferableDataHelper& rData,
SwWrtShell& rSh, sal_uLong nFmt,
sal_uInt16 nAction, const Point* pPt,
sal_uInt8 nActionFlags, sal_Bool bMsg )
sal_uInt8 nActionFlags, sal_Bool /* bMsg */)
{
int nRet = SwTransferable::_PasteGrf( rData, rSh, nFmt, nAction,
pPt, nActionFlags, bMsg );
pPt, nActionFlags, 0, false);
if( nRet )
nRet |= SWTRANSFER_GRAPHIC_INSERTED;
if( !nRet )
diff --git a/sw/source/ui/inc/swdtflvr.hxx b/sw/source/ui/inc/swdtflvr.hxx
index e790297..ad9d369 100644
--- a/sw/source/ui/inc/swdtflvr.hxx
+++ b/sw/source/ui/inc/swdtflvr.hxx
@@ -101,11 +101,11 @@
static int _PasteSdrFormat( TransferableDataHelper& rData,
SwWrtShell& rSh, sal_uInt16 nAction,
const Point* pPt, sal_uInt8 nActionFlags );
const Point* pPt, sal_uInt8 nActionFlags, bool bNeedToSelectBeforePaste);
static int _PasteGrf( TransferableDataHelper& rData, SwWrtShell& rSh,
sal_uLong nFmt, sal_uInt16 nAction, const Point* pPt,
sal_uInt8 nActionFlags, sal_Bool bMsg );
sal_uInt8 nActionFlags, sal_Int8 nDropAction, bool bNeedToSelectBeforePaste);
static int _PasteImageMap( TransferableDataHelper& rData,
SwWrtShell& rSh );
